home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / memory / xms200je / xms.h < prev    next >
C/C++ Source or Header  |  1993-11-22  |  11KB  |  230 lines
  1. //--------------------------------------------------------------------------
  2. //
  3. //      XMS.H: header file for XMS/UMB/HMA class library.
  4. //      Copyright (c) J.English 1993.
  5. //      Author's address: je@unix.brighton.ac.uk
  6. //
  7. //      Permission is granted to use copy and distribute the
  8. //      information contained in this file provided that this
  9. //      copyright notice is retained intact and that any software
  10. //      or other document incorporating this file or parts thereof
  11. //      makes the source code for the library of which this file
  12. //      is a part freely available.
  13. //
  14. //--------------------------------------------------------------------------
  15. //
  16. //      Revision history:
  17. //      2.0     Nov 1993        This file added to provide general XMS
  18. //                              facilities
  19. //                              
  20. //--------------------------------------------------------------------------
  21.  
  22. #ifndef __XMS_H
  23. #define __XMS_H
  24.  
  25. //--------------------------------------------------------------------------
  26. //
  27. //      Class XMS: wrapper class for XMS driver functions.
  28. //
  29. //      Declaring an object of this class allocates a new XMS handle.
  30. //      The constructor takes an optional long integer parameter giving
  31. //      the size of the XMS block to be allocated in bytes, which may be
  32. //      rounded up; if it is omitted, a block size of zero will be assumed.
  33. //      The following operations are available:
  34. //
  35. //      object.valid ()       -- Returns non-zero if the object has been
  36. //                               created successfully.
  37. //      !object               -- Returns the (non-zero) error code if the
  38. //                               object has NOT been created successfully.
  39. //      object.size ()        -- Returns the current block size in bytes.
  40. //      object.resize (n)     -- Resizes the block to "n" bytes.  Returns
  41. //                               a result of type XMS::error.
  42. //      object.at (n)         -- Returns a descriptor pointing to the
  43. //                               n-th byte of an XMS block (see below).
  44. //      object [n]            -- A synonym for "object.at (n)".
  45. //      XMS::copy (to,from,n) -- Copies "n" bytes from "from" to "to"; can
  46. //                               be used to copy from real memory to XMS or
  47. //                               vice versa or from XMS to XMS. For accessing
  48. //                               real memory, "to" or "from" can be a pointer
  49. //                               of any type; for accessing XMS, they must be
  50. //                               descriptors generated by "at" or the "[]"
  51. //                               operator (above).  Returns a result of type
  52. //                               XMS::error.
  53. //      XMS::available ()     -- Returns the total number of bytes of XMS
  54. //                               currently available.
  55. //      XMS::largest ()       -- Returns the size of the largest contiguous
  56. //                               unallocated XMS block in bytes.
  57. //
  58. //      Note that copy operations should specify an even number of bytes,
  59. //      and that source and destination should not overlap if an XMS-to-XMS
  60. //      copy is made.  Performance may be improved if copies to or from real
  61. //      memory are made to word aligned addresses (doubleword aligned for
  62. //      32-bit processors).
  63. //
  64. //      BEWARE: If programs are terminated abnormally, any existing XMS
  65. //      blocks will remain unrecoverably allocated.
  66.  
  67. class XMS
  68. {
  69.     struct XMSptr                           { int handle; long offset; };
  70.  
  71.   public:
  72.     enum error {                            // XMS error codes ...
  73.         SUCCESS                             = 0x00,
  74.         NO_DRIVER                           = 0x01,
  75.         INVALID_OBJECT                      = 0x02,
  76.         BLOCK_TOO_BIG                       = 0x03,
  77.         NOT_IMPLEMENTED                     = 0x80,
  78.         VDISK_DETECTED                      = 0x81,
  79.         A20_ERROR                           = 0x82,
  80.         GENERAL_DRIVER_ERROR                = 0x8E,
  81.         UNRECOVERABLE_DRIVER_ERROR          = 0x8F,
  82.         NO_HMA                              = 0x90,
  83.         HMA_IN_USE                          = 0x91,
  84.         HMA_REQUEST_TOO_SMALL               = 0x92,
  85.         NO_MORE_MEMORY                      = 0xA0,
  86.         NO_MORE_HANDLES                     = 0xA1,
  87.         BAD_HANDLE                          = 0xA2,
  88.         BAD_SRC_HANDLE                      = 0xA3,
  89.         BAD_SRC_OFFSET                      = 0xA4,
  90.         BAD_DST_HANDLE                      = 0xA5,
  91.         BAD_DST_OFFSET                      = 0xA6,
  92.         BAD_LENGTH                          = 0xA7,
  93.         OVERLAP_ERROR                       = 0xA8,
  94.         PARITY_ERROR                        = 0xA9,
  95.         BLOCK_LOCKED                        = 0xAB
  96.     };
  97.  
  98.     XMS    (long size = 0);                 // constructor
  99.     ~XMS   ();                              // destructor
  100.  
  101.     error  operator!  ()                    { return status; }
  102.     int    valid      ()                    { return (status == SUCCESS); }
  103.     long   size       ()                    { return allocation; }
  104.     error  resize     (long newsize);       // resize block
  105.  
  106.     XMSptr at         (long offset);        // offset into allocated block
  107.     XMSptr operator[] (long offset)         { return at (offset); }
  108.  
  109.     static error copy (const XMSptr& to,    // copy XMS -> XMS
  110.                        const XMSptr& from,  // (NB: to/from mustn't overlap)
  111.                        unsigned      len);  // length rounded down if odd
  112.  
  113.     static error copy (void far*     to,    // copy XMS -> conventional
  114.                        const XMSptr& from,
  115.                        unsigned      len);  // length rounded down if odd
  116.  
  117.     static error copy (const XMSptr& to,    // copy conventional -> XMS
  118.                        void far*     from,
  119.                        unsigned      len);  // length rounded down if odd
  120.  
  121.     static long       available ();         // get total size of free XMS
  122.     static long       largest   ();         // get size of largest free block
  123.  
  124.   private:
  125.     error status;
  126.     int   handle;
  127.     long  allocation;
  128. };
  129.  
  130. //--------------------------------------------------------------------------
  131. //
  132. //      Class UMB: wrapper class for XMS driver UMB functions.
  133. //
  134. //      Declaring an object of this class attempts to allocate an upper
  135. //      memory block (UMB) of the specified size.  The constructor takes
  136. //      a parameter specifying the block size in bytes, which may be
  137. //      rounded up.  The following operations are available:
  138. //
  139. //      UMB::largest ()     -- Returns the size of the largest available
  140. //                             UMB block in bytes.
  141. //      object.addr ()      -- Returns a pointer to the allocated UMB, or
  142. //                             a null pointer if the allocation failed.
  143. //      object.valid ()     -- Returns non-zero if the object has been
  144. //                             created successfully.
  145. //      !object             -- Returns the (non-zero) XMS error code if the
  146. //                             object has NOT been created successfully.
  147. //      object.size ()      -- Returns the actual allocated UMB size in bytes.
  148. //
  149. class UMB
  150. {
  151.   public:
  152.     UMB  (long size);                   // constructor
  153.     ~UMB ();                            // destructor
  154.  
  155.     static long largest   ();           // size of largest available block
  156.  
  157.     void huge*  addr      ()            { return address; }
  158.     XMS::error  operator! ()            { return status; }
  159.     int         valid     ()            { return (status == XMS::SUCCESS); }
  160.     long        size      ()            { return allocation; }
  161.  
  162.   private:
  163.     XMS::error status;
  164.     void huge* address;
  165.     long       allocation;
  166. };
  167.  
  168. //--------------------------------------------------------------------------
  169. //
  170. //      Class HMA: wrapper class for XMS driver HMA functions.
  171. //
  172. //      Declaring an object of this class attempts to allocate the HMA.
  173. //      The constructor takes an optional long integer parameter which
  174. //      gives the size of the HMA block to be allocated in bytes; if it
  175. //      is omitted, the maximum possible block size (0xFFF0 bytes) will
  176. //      be assumed.  The following operations are available:
  177. //
  178. //      object.valid ()       -- Returns non-zero if the HMA has been
  179. //                               allocated successfully.
  180. //      !object               -- Returns the (non-zero) XMS error code if the
  181. //                               HMA has NOT been allocated successfully.
  182. //      object.size ()        -- Returns the allocated HMA size in bytes.
  183. //      object.at (n)         -- Returns a descriptor pointing to the
  184. //                               n-th byte of the HMA (see below).
  185. //      object [n]            -- A synonym for "object.at (n)".
  186. //      XMS::copy (to,from,n) -- Copies "n" bytes from "from" to "to"; can
  187. //                               be used to copy from real memory to HMA or
  188. //                               vice versa or from HMA to HMA. For accessing
  189. //                               real memory, "to" or "from" can be a pointer
  190. //                               of any type; for accessing HMA, they must be
  191. //                               descriptors generated by "at" or the "[]"
  192. //                               operator (above).  Returns the number of
  193. //                               bytes actually copied.  Note that the source
  194. //                               and destination areas for HMS-to-HMS copy
  195. //                               operations should not overlap.
  196. //
  197. class HMA
  198. {
  199.     struct HMAptr                            { HMA* hma; unsigned offset; };
  200.  
  201.   public:
  202.     HMA  (unsigned size = 0xFFF0);           // constructor
  203.     ~HMA ();                                 // destructor
  204.  
  205.     XMS::error operator! ()                  { return status; }
  206.     int        valid     ()                  { return (status == XMS::SUCCESS); }
  207.     unsigned   size      ()                  { return allocation; }
  208.  
  209.     HMAptr at         (unsigned offset);     // offset into allocated block
  210.     HMAptr operator[] (unsigned offset)      { return at (offset); }
  211.  
  212.     static unsigned copy (const HMAptr& to,  // copy HMA -> HMA
  213.                           const HMAptr& from,
  214.                           unsigned      len);
  215.  
  216.     static unsigned copy (void far*     to,  // copy HMA -> conventional
  217.                           const HMAptr& from,
  218.                           unsigned      len);
  219.  
  220.     static unsigned copy (const HMAptr& to,  // copy conventional -> HMA
  221.                           void far*     from,
  222.                           unsigned      len);
  223.  
  224.   private:
  225.     XMS::error status;
  226.     unsigned   allocation;
  227. };
  228.  
  229. #endif
  230.